home *** CD-ROM | disk | FTP | other *** search
/ 5 Star Games: DOS Edition 2 / 5 Star Games - DOS Edition (1995)(Ready to Run).iso / dbc / db_list.c < prev    next >
C/C++ Source or Header  |  1992-06-03  |  16KB  |  579 lines
  1.  /****************************************************************************/
  2. /*                        DATABOSS MODULE: DB_LIST.C                        */
  3. /****************************************************************************/
  4.  
  5. #include "db_lsc.h"
  6.  
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include "db_types.h"
  11. #include "db_curs.h"
  12. #include "db_dos.h"
  13. #include "db_file.h"
  14. #include "db_gvar.h"
  15. #include "db_heap.h"
  16. #include "db_funcs.h"
  17. #include "db_key.h"
  18. #include "db_str.h"
  19. #include "db_tree.h"
  20. #include "db_win.h"
  21. #include "db_util.h"
  22. #include "db_list.h"
  23.  
  24. /*************************  INITIALIZED VARIABLES  **************************/
  25.  
  26. bool oldFindMethod = True;
  27.  
  28. /****************************  GLOBAL VARIABLES  ****************************/
  29.  
  30. byte        lwid;
  31. bool        brief;
  32. bool        listing;
  33. recnotyp    recno;
  34. recavailtyp recavail;
  35. rectabptr   rectab;
  36. linktyp     link;
  37. keyexprproc _keyexpr;
  38. getrecproc  _getarec;
  39. getstrfunc  _horizrec;
  40.  
  41. /***************************  INTERNAL VARIABLES  ***************************/
  42.  
  43. static byte         fno,
  44.                     kno,
  45.                     len,
  46.                     listmax,
  47.                     startpos,
  48.                     lastdirn;
  49. static indexfile   *idx;
  50. static bool         redraw,
  51.                     quit_flag;
  52. static int          scroll,
  53.                     midlist,
  54.                     savlen,
  55.                     listlen,
  56.                     listwid,
  57.                     listx,
  58.                     listy,
  59.                     savpos,
  60.                     pno,
  61.                     y,
  62.                     numup,
  63.                     numdn;
  64. static keystr       kystr,
  65.                     search,
  66.                     matchStrFind;
  67. static string       l_hdr,
  68.                     blnk;
  69. static winptr       fwinp,
  70.                     twinp;
  71.  
  72. static bool initialized = False;
  73.  
  74. /*****************************  IMPLEMENTATION  *****************************/
  75.  
  76. strptr defaultdata(string sout, ptr fb)
  77. {
  78.     bool    done;
  79.     word    w;
  80.     string  ts;
  81.     strptr  s;
  82.     int     tslen,slen;
  83.     fldblk *fblk;
  84.     fldtyp *fld;
  85.  
  86.     fblk = (fldblk *) fb;
  87.     done = False;
  88.     s = sout;
  89.     slen = 0;
  90.     w = 0;
  91.     fld = &(*(fblk->farr)[0]);
  92.     while ((w < fblk->numf) && !done) {
  93.         if ((fld->typ != _Memo) && (gvar->sec >= fld->dsec)) {
  94.             tslen = strlen(pic_fld(ts,fld->faddr,fld->typ,0,0,fld->pic));
  95.             if ((tslen+slen) > 252) {
  96.                 tslen = 252 - slen;
  97.                 ts[tslen] = '\0';
  98.             }
  99.             s = stpcpy(s," │ ");
  100.             s = stpcpy(s,ts);
  101.             done = (bool) ((slen += tslen + 3) > 252);
  102.         }
  103.         fld++;
  104.         w++;
  105.     }
  106.     *s = '\0';
  107.     return (sout);
  108. }
  109.  
  110. void fillrtab(tabtyp *t)
  111. {
  112.     string ts;
  113.  
  114.     t->ref = recno[fno];
  115.     if (brief)
  116.         strcpy(t->dsp,pad(ts,kystr,78,Right));
  117.     else {
  118.         _getarec(fno);
  119.         if (lockget)
  120.             t->ref = -(t->ref);
  121.         _horizrec(ts,_Data,fno,kno);
  122.         if (*ts == '\0') {
  123.             pad(ts,kystr,78,Right);
  124.             brief = True;
  125.         }
  126.         strcpy(t->dsp,ts);
  127.     }
  128. }
  129.  
  130. void refilltab(void)
  131. {
  132.     int i;
  133.     string ts;
  134.     strptr sp;
  135.  
  136.     i = (savpos != 0) ? savpos : (pno + midlist - 2) % listlen + 1;
  137.     if (lastdirn == DArr) {
  138.         while (labs((*rectab)[i].ref) != recno[fno])
  139.             prevkey(idx,&recno[fno],kystr);
  140.     }
  141.     if (lastdirn == UArr) {
  142.         while (labs((*rectab)[i].ref) != recno[fno])
  143.             nextkey(idx,&recno[fno],kystr);
  144.     }
  145.     _horizrec(l_hdr,_Header,fno,kno);
  146.     strcpy(blnk,l_hdr);
  147.     sp = blnk;
  148.     while (*sp != '\0') {
  149.         if (*sp != 0xB3)
  150.             *(sp++) = ' ';
  151.         else
  152.             sp++;
  153.     }
  154.  
  155.     pno = 1;
  156.     y = midlist;
  157.     do {
  158.         prevkey(idx,&recno[fno],kystr);
  159.     ok = ok && ((strsearch(kystr,matchStrFind) == kystr) || (strlen(matchStrFind) == 0) || oldFindMethod);
  160.         if (ok) y--;
  161.     } while (ok && (y != 1));
  162.  
  163.     if (!ok)
  164.         nextkey(idx,&recno[fno],kystr);
  165.     for (i = 1; i <= y-1; i++) {
  166.         (*rectab)[i].ref = 0;
  167.         strcpy((*rectab)[i].dsp,blnk);
  168.     }
  169.  
  170.     numup = midlist-y;
  171.     fillrtab(&(*rectab)[y]);
  172.     while (ok && (y < listlen)) {
  173.         nextkey(idx,&recno[fno],kystr);
  174.     ok = ok && ((strsearch(kystr,matchStrFind) == kystr) || (strlen(matchStrFind) == 0) || oldFindMethod);
  175.         if (ok)
  176.             fillrtab(&(*rectab)[++y]);
  177.     }
  178.  
  179.     if (!ok)
  180.         prevkey(idx,&recno[fno],kystr);
  181.     for (i = y+1; i <= listlen; i++) {
  182.         (*rectab)[i].ref = 0;
  183.         strcpy((*rectab)[i].dsp,blnk);
  184.     }
  185.  
  186.     numdn = y-midlist;
  187.     lastdirn = DArr;
  188.     if (brief) {
  189.         for (i = 1; i <= listlen + 1; i++)
  190.             writewxy(strcopy(ts,blnk,0,listwid),_av,1,(byte) i,fwinp);
  191.     }
  192.     writewxy(centre(ts,strcopy(ts,LSC_ListMenu,0,listwid),listwid),
  193.                         _ev,1,(byte)(listlen+2),fwinp);
  194.     redraw = True;
  195.    return;
  196. }
  197.  
  198. uchar display_list(int pno)
  199. {
  200.     byte lck;
  201.     uchar mv;
  202.     int z;
  203.     string ts;
  204.     strptr sp;
  205.  
  206.     if (redraw) {
  207.         writewxy(strcopy(ts,l_hdr,startpos-1,listwid),_iv,1,1,fwinp);
  208.         for (z = 1; z <= listlen; z++) {
  209.             lck = (byte) (((*rectab)[z].ref < 0) ? 0x80 : 0x00);
  210.             writewxy(strcopy(ts,(*rectab)[z].dsp,startpos-1,listwid),
  211.                         (byte)(_av | lck),1,(byte)((z-pno+listlen)%listlen+2),fwinp);
  212.         }
  213.         z = ((pno+midlist-2)%listlen)+1;
  214.         lck = (byte) (((*rectab)[z].ref < 0) ? 0x80 : 0x00);
  215.         writewxy(strcopy(ts,(*rectab)[z].dsp,startpos-1,listwid),
  216.                             (byte)(_ev | lck),1,(byte)(midlist+1),fwinp);
  217.         redraw = False;
  218.     }
  219.     lck = fwinp->wid-2-strlen(search);
  220.     sp = stpcpy(ts,search);
  221.     sp = stpcpy(sp,"\xFF\x01");
  222.     *(sp++) = lck;
  223.     *(sp++) = fwinp->borchrs[4];
  224.     *sp = '\0';
  225.     writewxy(ts,0,(byte)(fwinp->x+1),(byte)(fwinp->y+fwinp->hgt),NULL);
  226.     if (scroll == 0)
  227.         mv = getkey();
  228.     return (mv);
  229. }
  230.  
  231. long list_n_choose(byte _fno, byte _kno, keystr _kystr, indexfile *_idx, findwtyp wdim)
  232. {
  233.     long   fval;
  234.     string ts;
  235.     int    i,slen;
  236.     uchar  action,inp;
  237.  
  238.   trim(matchStrFind,_kystr);
  239.     fno = _fno;
  240.     kno = _kno;
  241.     strcpy(kystr,_kystr);
  242.     idx = _idx;
  243.  
  244.     if (!(wdim.h % 2))                wdim.h--;
  245.    if (wdim.h < 5)                   wdim.h = 5;
  246.    if (wdim.h > (scrhgt - 4))        wdim.h = 21;
  247.     if (wdim.w < lwid)                wdim.w = lwid;
  248.    if (wdim.w > (scrwid - 2))        wdim.w = scrwid - 2;
  249.    if (wdim.x < 2)                   wdim.x = 2;
  250.    if (wdim.x > (scrwid - 4))        wdim.x = scrwid - 4;
  251.    if (wdim.y < 2)                   wdim.y = 2;
  252.    if (wdim.y > (scrhgt - 4))        wdim.y = scrhgt - 4;
  253.     if (((wdim.x + wdim.w) > scrwid)) wdim.x = 2;
  254.     if (((wdim.y + wdim.h) > scrhgt)) wdim.y = 2;
  255.  
  256.     fval      = -1;
  257.     link      = No_Link;
  258.     lastdirn  = ' ';
  259.    action    = ' ';
  260.     search[0] = '\0';
  261.     startpos  = pno       = 1;
  262.     savpos    = scroll    = 0;
  263.     brief     = quit_flag = False;
  264.     listlen   = wdim.h;
  265.    listwid   = wdim.w;
  266.     listx     = wdim.x;
  267.    listy     = wdim.y;
  268.     midlist   = (listlen/2) + 1;
  269.     listmax   = scrhgt - 4;
  270.     if (listmax == 46) listmax = 45;
  271.  
  272.     if ((_getarec != NULL) && (_horizrec != NULL) &&
  273.         openwin(0, listx, listy, 78, (byte)(listmax+2), 15, 31, 8, "─┐│┘─└│┌", TopCnt, strconcat(ts," ", LSC_ListOf, " ", NULL))) {
  274.         fwinp = curwin;
  275.         resizewin(0,0,listwid-78,listlen-listmax,fwinp);
  276.         hidewin(T_ON,fwinp);
  277.         refilltab();
  278.         delay(100);
  279.         kflush();
  280.         do {
  281.             if (scroll > 0) {
  282.                 display_list(pno);
  283.                 switch (action) {
  284.                     case PgUp :
  285.                     case UArr :
  286.                         if (numup > 0) {
  287.                             pno = (pno + listlen-2) % listlen + 1;
  288.                             if (lastdirn != UArr) {
  289.                                 lastdirn = UArr;
  290.                                 for (i = 1; i <= numup+numdn; i++) prevkey(idx,&recno[fno],kystr);
  291.                             }
  292.                             prevkey(idx,&recno[fno],kystr);
  293.               ok = ok && ((strsearch(kystr,matchStrFind) == kystr) || (strlen(matchStrFind) == 0) || oldFindMethod);
  294.                             if (ok) fillrtab(&(*rectab)[pno]);
  295.                             else {
  296.                                 numup--;
  297.                                 (*rectab)[pno].ref = 0;
  298.                                 strcpy((*rectab)[pno].dsp,blnk);
  299.                                 nextkey(idx,&recno[fno],kystr);
  300.                             };
  301.                             if (numdn < (midlist-1)) numdn++;
  302.                             redraw = True;
  303.                         }
  304.                         else {
  305.                             audible(Warning);
  306.                             scroll = 1;
  307.                         }
  308.                         break;
  309.                     case PgDn :
  310.                     case DArr :
  311.                         if (numdn > 0) {
  312.                             if (lastdirn != DArr) {
  313.                                 lastdirn = DArr;
  314.                                 for (i = 1; i <= numup+numdn; i++) nextkey(idx,&recno[fno],kystr);
  315.                             }
  316.                             nextkey(idx,&recno[fno],kystr);
  317.               ok = ok && ((strsearch(kystr,matchStrFind) == kystr) || (strlen(matchStrFind) == 0) || oldFindMethod);
  318.                             if (ok) fillrtab(&(*rectab)[pno]);
  319.                             else {
  320.                                 numdn--;
  321.                                 (*rectab)[pno].ref = 0;
  322.                                 strcpy((*rectab)[pno].dsp,blnk);
  323.                                 prevkey(idx,&recno[fno],kystr);
  324.                             }
  325.                             pno = pno % listlen + 1;
  326.                             if (numup < (midlist-1)) numup++;
  327.                             redraw = True;
  328.                         }
  329.                         else {
  330.                             audible(Warning);
  331.                             scroll = 1;
  332.                         }
  333.                         break;
  334.                 }
  335.                 scroll--;
  336.             }
  337.             else {
  338.                 action = display_list(pno);
  339.                 if (_xkey || (action == Enter)) search[0] = '\0';
  340.                 switch (action) {
  341.                     case _AltZoom :
  342.                         hidewin(T_OFF,fwinp);
  343.                         savpos = (pno + midlist - 2) % listlen + 1;
  344.                         if ((listwid == 78) && (listlen == listmax)) {
  345.                             movewin(wdim.x,wdim.y,fwinp);
  346.                             listx = wdim.x;
  347.                      listy = wdim.y;
  348.                             resizewin(0,0,wdim.w-78,wdim.h-listmax,fwinp);
  349.                             listwid = wdim.w;
  350.                      listlen = wdim.h;
  351.                         }
  352.                         else {
  353.                             movewin(2,2,fwinp);
  354.                             listx = 2;
  355.                             listy = 2;
  356.                             resizewin(0,0,78-listwid,listmax-listlen,fwinp);
  357.                             listwid = 78;
  358.                             listlen = listmax;
  359.                         }
  360.                         midlist = (listlen/2) + 1;
  361.                         refilltab();
  362.                         savpos = 0;
  363.                         hidewin(T_ON,fwinp);
  364.                         break;
  365.                     case _AltResize :
  366.                         len = (byte) maximum(strlen(LSC_UsePr + 5), strlen(LSC_ToFinish));
  367.                         if (openwin(0,listx+1,listy+1,len,2,31,31,8,"─┐│┘─└│┌",TopCnt,
  368.                                         strconcat(ts," ",LSC_Resize," ",NULL))) {
  369.                             twinp = curwin;
  370.                             twinp->disp = True;
  371.                             dispwindow(twinp);
  372.                             writewxy(centre(ts,strconcat(ts,LSC_UsePr,
  373.                                                 " \x1B\x1A\x18\x19",NULL),len),31,1,1,twinp);
  374.                             writewxy(centre(ts,LSC_ToFinish,len),31,1,2,twinp);
  375.                             savlen = listlen;
  376.                             savpos = (pno + midlist - 2) % listlen + 1;
  377.                             do {
  378.                                 inp = upperch(getkey());
  379.                                 switch (inp) {
  380.                                     case RArr :
  381.                                         if ((listwid+listx-1) < 78) {
  382.                                             listwid++;
  383.                                             resizewin(0,0,1,0,fwinp);
  384.                                             for (i=2; i <= (listlen+2); i++)
  385.                                                 writewxy(" ",_av,(byte) listwid,(byte )i,fwinp);
  386.                                         }
  387.                                     break;
  388.                                     case LArr :
  389.                                         if (listwid > strlen(LSC_ListMenu)) {
  390.                                             listwid--;
  391.                                             resizewin(0,0,-1,0,fwinp);
  392.                                         }
  393.                                     break;
  394.                                     case DArr :
  395.                                         if ((listlen+listy) < listmax) {
  396.                                             listlen += 2;
  397.                                             resizewin(0,0,0,2,fwinp);
  398.                                             writewxy(strcopy(ts,blnk,0,listwid),_av,1,(byte)(listlen+2),fwinp);
  399.                                             writewxy(strcopy(ts,blnk,0,listwid),_av,1,(byte)(listlen+1),fwinp);
  400.                                             writewxy(strcopy(ts,blnk,0,listwid),_av,1,(byte) listlen,fwinp);
  401.                                         }
  402.                                     break;
  403.                                     case UArr :
  404.                                         if (listlen > 6) {
  405.                                             listlen -=2;
  406.                                             resizewin(0,0,0,-2,fwinp);
  407.                                         }
  408.                                     break;
  409.                                 }
  410.                             } while ((inp == RArr) || (inp == DArr) || (inp == LArr) || (inp == UArr));
  411.  
  412.                             if (savlen != listlen)     midlist = (listlen/2) + 1;
  413.                             refilltab();
  414.                             savpos = 0;
  415.                             closewin(&twinp);
  416.                             wdim.h = (byte)listlen;
  417.                      wdim.w = (byte)listwid;
  418.                             wdim.x = (byte)listx;
  419.                      wdim.y = (byte)listy;
  420.                         }
  421.                         break;
  422.                     case _AltMove :
  423.                         len = (byte) max(strlen(LSC_UsePr)+5,strlen(LSC_ToFinish));
  424.                         if (openwin(0,listx+1,listy+1,len,2,31,31,8,"─┐│┘─└│┌",TopCnt,strconcat(ts," ",LSC_Move," ",NULL))) {
  425.                             twinp = curwin;
  426.                             twinp->disp = True;
  427.                             dispwindow(twinp);
  428.                             writewxy(centre(ts,strconcat(ts,LSC_UsePr," \x1B\x1A\x18\x19",NULL),len),31,1,1,twinp);
  429.                             writewxy(centre(ts,LSC_ToFinish,len),31,1,2,twinp);
  430.                             do {
  431.                                 inp = upperch(getkey());
  432.                                 switch (inp) {
  433.                                     case RArr :
  434.                                         if ((listx+listwid) < 80) {
  435.                                             listx++;
  436.                                             scrollwin(3,fwinp);
  437.                                             scrollwin(3,twinp);
  438.                                         }
  439.                                     break;
  440.                                     case LArr :
  441.                                         if (listx > 2) {
  442.                                             listx--;
  443.                                             scrollwin(2,fwinp);
  444.                                             scrollwin(2,twinp);
  445.                                         }
  446.                                     break;
  447.                                     case DArr :
  448.                                         if ((listy+listlen) < (listmax+2)) {
  449.                                             listy++;
  450.                                             scrollwin(1,fwinp);
  451.                                             scrollwin(1,twinp);
  452.                                         }
  453.                                     break;
  454.                                     case UArr :
  455.                                         if (listy > 2) {
  456.                                             listy--;
  457.                                             scrollwin(0,fwinp);
  458.                                             scrollwin(0,twinp);
  459.                                         }
  460.                                     break;
  461.                                 }
  462.                             } while ((inp == RArr) || (inp == DArr) || (inp == LArr) || (inp == UArr));
  463.                             closewin(&twinp);
  464.                             wdim.h = (byte) listlen;
  465.                      wdim.w = (byte) listwid;
  466.                             wdim.x = (byte) listx;
  467.                      wdim.y = (byte) listy;
  468.                         }
  469.                         break;
  470.                     case _AltBrief :
  471.                         brief = (bool) (!brief);
  472.                         refilltab();  startpos = 1;
  473.                         break;
  474.                     case Enter :
  475.                     case XeptKey :
  476.                         fval = labs((*rectab)[((pno+midlist-2)%listlen)+1].ref);
  477.                         quit_flag = True;
  478.                         break;
  479.                     case QitKey :
  480.                         if (!listing) {
  481.                             fval = 0;
  482.                             quit_flag = True;
  483.                         }
  484.                         else
  485.                             audible(Pip);
  486.                         break;
  487.                     case UArr :
  488.                     case DArr :
  489.                         scroll = 1;
  490.                         break;
  491.                     case PgUp :
  492.                     case PgDn :
  493.                         scroll = 10;
  494.                         break;
  495.                     case RArr :
  496.                         if ((!brief) && ((startpos+listwid) < 255)) {
  497.                             startpos++;
  498.                             redraw = True;
  499.                         }
  500.                         else
  501.                             audible(Warning);
  502.                         break;
  503.                     case LArr :
  504.                         if ((!brief) && (startpos > 1)) {
  505.                             startpos--;
  506.                             redraw = True;
  507.                         }
  508.                         else
  509.                             audible(Warning);
  510.                         break;
  511.                     case CtrlRArr :
  512.                     case Tab :
  513.                         if ((!brief) && ((startpos+listwid) < 255)) {
  514.                             if ((startpos+listwid) < 245) startpos += 10;
  515.                             else                          startpos = (byte) (255 - listwid);
  516.                             redraw = True;
  517.                         }
  518.                         else
  519.                             audible(Warning);
  520.                         break;
  521.                     case CtrlLArr :
  522.                     case STab :
  523.                         if ((!brief) && (startpos > 1)) {
  524.                             if (startpos > 10) startpos -= 10;
  525.                             else               startpos = 1;
  526.                             redraw = True;
  527.                         }
  528.                         else
  529.                             audible(Warning);
  530.                         break;
  531.           default:
  532.             slen = strlen(search);
  533.             if (!_xkey) {
  534.               if (action != BackSp) {
  535.                 search[slen] = action;
  536.                 if ((slen+1) < sizeof(search)) slen++;
  537.               }
  538.               else if (slen > 0) slen--;
  539.               search[slen] = '\0';
  540.               if (slen > 0) strcpy(kystr,search); else strcpy(kystr,matchStrFind);
  541.               if (_keyexpr != NULL) _keyexpr(kystr,fno,kno,kystr);
  542.               searchkey(idx,&recno[fno],kystr);
  543.               if (!ok) prevkey(idx,&recno[fno],kystr);
  544.               lastdirn = ' ';  savpos = 0;
  545.               strcopy(matchStrFind,kystr,0,slen);
  546.               refilltab();
  547.             }
  548.           break;
  549.                 }
  550.             }
  551.         } while (!quit_flag);
  552.         closewin(&fwinp);
  553.     }
  554.     link = Up_N_Down;
  555.     return (fval);
  556. }
  557.  
  558. /**********************  UNIT INITIALIZATION/EXIT CODE  *********************/
  559.  
  560. void db_list_init(void)
  561. {
  562.     if (!initialized) {
  563.         initialized = True;
  564.         db_curs_init();
  565.         db_funcs_init();
  566.         db_key_init();
  567.         db_tree_init();
  568.         db_util_init();
  569.         db_win_init();
  570.         rectab = db_malloc(sizeof(rectabtyp));
  571.         _keyexpr = NULL;
  572.         _getarec = NULL;
  573.         _horizrec = NULL;
  574.         lwid = (byte) strlen(LSC_ListMenu);
  575.     }
  576. }
  577.  
  578. /****************************  END OF DB_LIST.C  ****************************/
  579.